import _ from 'lodash'

export function moduleStyle (params) {
  let style
  let moduleList = _.cloneDeep(params)
  moduleList.forEach(item => {
    style = {}
    if (item.moduleSeat.length > 0) {
      switch (item.moduleSeat[0]) {
        case 0:
          style.left = '0'
          style.top = '0px'
          break
        case 1:
          style.left = '25%'
          style.top = '0px'
          break
        case 2:
          style.left = '50%'
          style.top = '0px'
          break
        case 3:
          style.left = '75%'
          style.top = '0px'
          break
        case 4:
          style.left = '0'
          style.top = '33%'
          break
        case 5:
          style.left = '25%'
          style.top = '33%'
          break
        case 6:
          style.left = '50%'
          style.top = '33%'
          break
        case 7:
          style.left = '75%'
          style.top = '33%'
          break
        case 8:
          style.left = '0'
          style.top = '66%'
          break
        case 9:
          style.left = '25%'
          style.top = '66%'
          break
        case 10:
          style.left = '50%'
          style.top = '66%'
          break
        case 11:
          style.left = '75%'
          style.top = '66%'
          break
      }
    }
    item.style = style
  })
  return moduleList
}

export function getModuleSeat (params) {
  let moduleSeat = []
  params.forEach(item => {
    moduleSeat = [...moduleSeat, ...item.moduleSeat]
  })
  return moduleSeat
}

// 根绝单个模块的moduleType获取这个模块的占位熟练moduleSize, 横向占比长度moduleWidthX， 垂直占比长度moduleHeightY
export function getOnceSize (params) {
  let module = params.moduleType.split('x')
  return {
    moduleSize: Number(module[0]) * Number(module[1]),
    moduleWidthX: Number(module[0]),
    moduleHeightY: Number(module[1])
  }
}

// 根据当前占位获取单个模块的所有占位
// params.currentSeat为当前占位索引
// params.module为单个模块信息其中包含moduleWidthX横向占长度(1, 2, 3, 4)，moduleHeightY垂直方向占长度(1, 2, 3)
// params.moduleSeat已经被其他模块所占用的位置值，全值为[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 当这个值存在的时候，
// 函数会进行单个模块位置与其他模块所占用的位置是否有交集处理
export function getOnceSeat (params) {
  let moduleSeat = []
  let moduleSeatX = []
  let moduleSeatY = []
  for (let i = 0; i < params.module.moduleWidthX; i++) {
    moduleSeatX.push(params.currentSeat + i)
  }
  // 获取当前行中最大数据值
  let maxSeatX = (parseInt(params.currentSeat / 4) + 1) * 4 - 1
  // 判断moduleSeatX最后一位是否大于第一数据所在行的最大数据值如，3,7,11
  if (moduleSeatX[moduleSeatX.length - 1] <= maxSeatX) {
    // 当当前选项的Y值大于1的时候，才需要添加moduleSeatY数据
    if (params.module.moduleHeightY > 1) {
      for (let i = 1; i < params.module.moduleHeightY; i++) {
        moduleSeatX.forEach(item => {
          moduleSeatY.push(item + 4 * i)
        })
      }
    }
    moduleSeat = [...moduleSeatX, ...moduleSeatY]
  }
  if (params.moduleSeat) {
    let flag = false
    // 判断新模块所需要的位置是否已经被其他模块占用
    moduleSeat.forEach(item => {
      if (params.moduleSeat.includes(item)) {
        flag = true
      }
    })
    // 超出边框的时候，返回空数组
    if (moduleSeat[moduleSeat.length - 1] > 11) {
      flag = true
    }
    moduleSeat = flag ? [] : moduleSeat
  } else {
    if (moduleSeat[moduleSeat.length - 1] > 11) {
      let newModuleSeat = []
      moduleSeat.forEach(item => {
        newModuleSeat.push(item - (moduleSeat[(moduleSeat.length) / 2] - moduleSeat[0]))
      })
      moduleSeat = newModuleSeat
    }
  }
  return moduleSeat
}

// 根据传入的当前模块位置，而获取原来位置上的组件的所有位置（不包含当前模块的原来位置与新位置不重合部分）,
// params.currentModuleSeat当前模块位置
// params.moduleList模块列表
// params.currentIndex
export function getOriginalAllSeat (params) {
  // 原组件所占位置
  let allSeat = []
  // 拖拽模块前后位置是否有交集
  let isIntersection = false
  // 拖拽后，把拖拽组件新位置上的原组件moduleSeat清空，
  let moduleList = []
  // 用于moduleSeat清空的时候，数据暂存
  let itemObj
  // 被清空位置的原始索引
  let indexArr = []
  // 拖拽模块前后位置是否有交集，被清空位置的索引，被编辑过
  let indexSort = []
  // 被清空位置的第一位置值
  let moduleFirstSeat = []
  params.moduleList.forEach((item, index) => {
    if (item.moduleSeat.length === 0) {
      moduleList.push(item)
    } else {
      // 拖拽模块原位置与新位置重合部分
      if (params.currentIndex === index) {
        for (let i = 0; i < item.moduleSeat.length; i++) {
          if (params.currentModuleSeat.includes(item.moduleSeat[i])) {
            allSeat = [...allSeat, ...[item.moduleSeat[i]]]
            isIntersection = true
          }
        }
        moduleList.push(item)
      } else {
        for (let i = 0; i < item.moduleSeat.length; i++) {
          // 当前模块的位置值存与拖拽模块新的位置值有交集的时候
          if (params.currentModuleSeat.includes(item.moduleSeat[i])) {
            allSeat = [...allSeat, ...item.moduleSeat]
            itemObj = _.cloneDeep(item)
            itemObj.moduleSeat = []
            moduleList.push(itemObj)
            moduleFirstSeat.push(item.moduleSeat[0])
            indexArr.push(index)
            break
          }
          // 当循环到最后一个的时候，还没有位置与拖拽模块新位置重合，那么把这个值放在moduleList里面
          if (i === item.moduleSeat.length - 1) {
            moduleList.push(item)
          }
        }
      }
    }
  })
  // 把清空位置的按模块面积大小排序，面积一样的，按X轴大的优先排序，X轴一样的，按照Y轴大的优先排序，X轴Y轴一样的，按照原来排序的先后排序
  let moduleSize = []
  let moduleMessage
  // 按照原来排序的先后排序
  moduleFirstSeat.sort(function (a, b) {
    return a - b
  })
  moduleFirstSeat.forEach(item => {
    params.moduleList.forEach((moduleItem, index) => {
      if (moduleItem.moduleSeat.includes(item)) {
        moduleMessage = getOnceSize(params.moduleList[index])
        indexSort.push(index)
        moduleSize.push(moduleMessage.moduleSize)
      }
    })
  })
  // 面积排序
  let sortMessage = sortArray({ moduleArr: moduleSize, indexSort: indexSort })
  return { allSeat, moduleList, indexArr, isIntersection, sortMessage }
}

// 根据当前数组排序，返回排序后的数组，并把排序前的数组元素index根据数据排序，并返回
export function sortArray (params) {
  let arr = []
  params.moduleArr.forEach((item, index) => {
    arr.push([params.indexSort[index], item])
  })
  arr.sort(function (a, b) {
    if (a[1] > b[1]) {
      return -1
    }
    if (a[1] < b[1]) {
      return 1
    }
    return 0
  })
  // 排序后的indexSort序列
  let moduleIndexSort = []
  let moduleArr = []
  // params.moduleArr前后两项数据一样的时候，需要返回出去
  let equallyIndex = []
  arr.forEach((item, index) => {
    if (item[1] === 2 && index > 0 && item[1] === arr[index - 1][1]) {
      if (equallyIndex.includes(arr[index - 1][0])) {
        equallyIndex.push(arr[index - 1][0])
      } else {
        equallyIndex.push(arr[index - 1][0], item[0])
      }
    }
    moduleIndexSort.push(item[0])
    moduleArr.push(item[1])
  })
  return { moduleIndexSort, moduleArr, allMessage: arr, equallyIndex }
}

// 根据接口返回的数据，计算模块的moduleSeat
export function calculationModuleSeat (params) {
  let module = []
  let moduleId = []
  let moduleObj = {}
  if (params.constructor === Array) {
    params.forEach(item => {
      module.push({
        id: item.id,
        moduleSeat: moduleSeatFromXY(item)
      })
      moduleId.push(item.id)
      moduleObj[item.id] = {
        seat: moduleSeatFromXY(item),
        refreshInterval: Number(item.refreshInterval) ? Number(item.refreshInterval) : 0,
        organType: Number(item.organType) ? Number(item.organType) : 0
      }
    })
  }
  return { module, moduleId, moduleObj }
}

// 根据接口的数据返回单个模块seat
export function moduleSeatFromXY (data) {
  let left = 0
  let top = 0
  let width = 1
  let height = 1
  let currentSeat = 0
  let moduleSeat = []
  switch (data.pointX) {
    case '0': left = 0
      break
    case '1': left = 1
      break
    case '2': left = 2
      break
    case '3': left = 3
      break
  }
  switch (data.pointY) {
    case '0': top = 0
      break
    case '1': top = 1
      break
    case '2': top = 2
      break
  }
  switch (data.numsX) {
    case '1': width = 1
      break
    case '2': width = 2
      break
    case '3': width = 3
      break
  }
  switch (data.numsY) {
    case '1': height = 1
      break
    case '2': height = 2
      break
    case '3': height = 3
      break
  }
  currentSeat = left + top * 4
  for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
      moduleSeat.push((currentSeat + x) + y * 4)
    }
  }
  return moduleSeat
}

// 处理后接口的数据和moduleList进行映射,
// params.module
// params.moduleList
// params.moduleId 模块ID集
// params.moduleObj 模块集，以模块Id为键名
export function moduleToModuleList (params) {
  let moduleList = _.cloneDeep(params.moduleList)
  // 清空上一个状态的moduleSeat
  moduleList.forEach(item => {
    item.moduleSeat = []
  })
  // 赋值新的moduleSeat
  moduleList.forEach(item => {
    if (params.moduleId.includes(item.id)) {
      item.moduleSeat = params.moduleObj[item.id].seat
      item.refreshInterval = params.moduleObj[item.id].refreshInterval
      item.organType = params.moduleObj[item.id].organType
    }
  })
  return moduleList
}

// 把当前模块数据上传至接口
export function moduleListToModule (params) {
  let module = []
  if (params.moduleList.constructor === Array) {
    params.moduleList.forEach(item => {
      if (item.moduleSeat.length > 0) {
        module.push({
          id: item.id,
          pointX: item.moduleSeat[0] % 4,
          pointY: Math.floor(item.moduleSeat[0] / 4),
          seat: item.moduleSeat
        })
      }
    })
  }
  return module
}

// 根据接口返回数据，控制那些模块试可以选择显示的，接口不返回模块隐藏处理
export function showSelectModule (params) {
  let moduleIdArr = []
  params.data.forEach(item => {
    moduleIdArr.push(item.id)
  })
  params.moduleList.forEach(item => {
    if (moduleIdArr.includes(item.id)) {
      item.show = true
    } else {
      item.show = false
    }
  })
  return params.moduleList
}
